home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 2.iso / BARNET / COMPILER / SATHER / !Sather / Library / Containrs / sa / array2 < prev    next >
Text File  |  1996-08-01  |  7KB  |  198 lines
  1. ---------------------------> Sather 1.1 source file <--------------------------
  2. -- Copyright (C) International Computer Science Institute, 1994.  COPYRIGHT  --
  3. -- NOTICE: This code is provided "AS IS" WITHOUT ANY WARRANTY and is subject --
  4. -- to the terms of the SATHER LIBRARY GENERAL PUBLIC LICENSE contained in    --
  5. -- the file "Doc/License" of the Sather distribution.  The license is also   --
  6. -- available from ICSI, 1947 Center St., Suite 600, Berkeley CA 94704, USA.  --
  7. --------> Please email comments to "sather-bugs@icsi.berkeley.edu". <----------
  8.  
  9. -- array2.sa: Two-dimensional arrays.
  10.  
  11. -- Notes: a new set of identifier is provided for consistency with
  12. -- ARRAY3, like size1, size2, ind1!, ind2!, elt1!,elt2! and so on.
  13. -------------------------------------------------------------------
  14.  
  15. class ARRAY2{T} < $ELT{T} is
  16.    -- Two-dimensional arrays of elements of type T.
  17.    private include AREF{T}   aclear->aclear, array_ptr->array_ptr;
  18.    
  19.    readonly attr size2:INT;    -- Size of the fastest changing dimension.
  20.  
  21.    readonly attr size1:INT;     -- Size of the slowest changing dimension.
  22.  
  23.    create(d1,d2:INT):SAME 
  24.       -- A new two-dimensional array with dimensions `d1 x d2'
  25.       -- initialized to void.
  26.       pre d1>0 and d2>0 is
  27.       res::=new(d1*d2);
  28.       res.size1:=d1;
  29.       res.size2:=d2;
  30.       return(res); end;
  31.  
  32.    create(a: ARRAY{ARRAY{T}}): SAME 
  33.       -- Create a new array with the same dimensions and values as
  34.       -- a, which is an array of arrays(rows). 
  35.       -- Assume that all the rows of "a" have the same number of elements
  36.       pre a.size > 0 and a[0].size > 0 is
  37.       sz1 ::= a.size;
  38.       sz2 ::= a[0].size;
  39.       res ::= #SAME(sz1,sz2);
  40.       loop r::=sz1.times!; 
  41.      loop c::=sz2.times!; res[r,c] := a[r][c]; end; 
  42.       end;
  43.       return(res);
  44.       end;
  45.      
  46.    copy: SAME 
  47.       -- Return a new 2D array with the same set of values as self
  48.       pre ~void(self) and size1 > 0 and size2 > 0 is
  49.       res ::= #SAME(size1,size2);
  50.       res.acopy(self);
  51.       return(res);
  52.       end;
  53.       
  54.    copy(a: ARRAY{ARRAY{T}}) is
  55.       -- Copy as much of a as will fit into self
  56.       loop 
  57.      r::=size1.min(a.size).times!;
  58.      row ::= a[r];
  59.      loop set_row!(r,row.elt!) end end end;   
  60.  
  61.    aget(i1,i2:INT):T is
  62.       -- The element with indices `[i1,i2]'.
  63.       return([i1*size2+i2]) end;
  64.  
  65.    aset(i1,i2:INT,val:T) is
  66.       -- Set the element with indices `[i1,i2]' to val.
  67.       [i1*size2+i2]:=val end;      
  68.  
  69.    nr: INT is 
  70.       -- The size of the first dimension of the array. Number of rows
  71.       return size1 end;
  72.    
  73.    nc: INT is
  74.       -- The size of the second dimension of the array. Number of cols
  75.       return size2 end;
  76.  
  77.    ind1!: INT is
  78.       -- Yield each value of the first index in order. The rows
  79.       loop yield(size1.times!); end end;
  80.    
  81.    ind2!:INT is
  82.       -- Yield each value of the second index in order. The columns
  83.       loop yield(size2.times!); end end;
  84.  
  85.    row_ind!: INT is
  86.       -- Yield each value of the first index in order. The rows
  87.       loop yield(size1.times!); end end;
  88.    
  89.    col_ind!:INT is
  90.       -- Yield each value of the second index in order. The columns
  91.       loop yield(size2.times!); end end;
  92.    
  93.    diag_elt!: T is
  94.       -- Yield values along the diagonal (square in smaller dimension)
  95.       loop ind ::= (size1.min(size2)).times!; yield([ind,ind]) end; end;
  96.  
  97.    set_diag_elt!(val:T) is
  98.       -- Set values along the diagonal (square in smaller dimension)
  99.       loop id ::= (size1.min(size2)).times!; [id,id] := val; yield;  end; end;
  100.    
  101.    inds!:TUP{INT,INT} is
  102.       -- Yield tuples of the indices of self in lexicographical order.
  103.       loop row ::=size1.times!;
  104.      loop yield(#TUP{INT,INT}(row,size2.times!)); end end end;
  105.  
  106.    elt!: T is
  107.       -- Yield all elements in row major order
  108.       loop yield(aelt!) end; end;
  109.    
  110.    set!(val:T) is
  111.       -- Set all elements in row major order
  112.       loop aset!(val); yield; end end;
  113.  
  114.    elt1!(once i1:INT):T is
  115.       -- Yield elements by varying index 2 and holding index 1 at `i1'.
  116.       -- The elements of a row "i1"
  117.       -- this is the same as row_elt!
  118.       loop yield(aelt!(i1*size2,size2,1)); end end;
  119.  
  120.    elt2!(once i2:INT):T is
  121.       -- Yield elements by varying index 1 and holding index 2 at `i2'.
  122.       -- The elements of a "column" i2
  123.       -- this is the same as col_elt!
  124.       loop yield(aelt!(i2,size1,size2)); end end;
  125.       
  126.    row_elt!(once row:INT):T is
  127.       -- Yield elements by varying index 2 and holding index 1 at `row'.
  128.       -- The elements of a row "row"
  129.       loop yield(aelt!(row*size2,size2,1)); end end;
  130.  
  131.    col_elt!(once col:INT):T is
  132.       -- Yield elements by varying index 1 and holding index 2 at `col'.
  133.       -- The elements of a "column" col
  134.       loop yield(aelt!(col,size1,size2)); end end;
  135.  
  136.    set1!(once i1:INT, val:T) is
  137.       -- Set to val elements with varying index 2 and index 1 fixed at `i1'.
  138.       -- i.e. setting the row i1
  139.       -- this is the same as set_row!
  140.       loop aset!(i1*size2,size2,val); yield end end;
  141.  
  142.    set2!(once i2:INT, val:T) is
  143.       -- Set to val elements with varying index 1 and index 2 fixed at `i2'.
  144.       -- i.e. setting the column i2 
  145.       -- this is the same as set_col!
  146.       loop aset!(i2,size1,size2,val); yield end end;
  147.  
  148.    set_row!(once row:INT, val:T) is
  149.       -- Set to val elements with varying index 2 and index 1 fixed at `row'.
  150.       -- i.e. setting a row "row"
  151.       loop aset!(row*size2,size2,val); yield end end;
  152.  
  153.    set_col!(once col:INT, val:T) is
  154.       -- Set to val elements with varying index 1 and index 2 fixed at `col'.
  155.       -- i.e. setting the column col 
  156.       loop aset!(col,size1,size2,val); yield end end;
  157.  
  158.    transpose: SAME is
  159.       -- Return a new array containing the transpose of self
  160.       res::=#SAME(size2,size1);
  161.       res.to_transpose_of(self);
  162.       return(res) end;
  163.    
  164.    to_transpose_of(a:SAME)
  165.       -- Set self to the transpose of a.
  166.       pre a.size1=size2 and a.size2=size1 is
  167.       loop t::=inds!; [t.t1,t.t2]:=a[t.t2,t.t1] end;
  168.       end;
  169.    
  170.    to_portion_of(a: SAME) is
  171.       -- Copy into self as much of arg as will fit and return it. Don't
  172.       -- alter other elements.
  173.       loop r::=size1.min(a.size1).times!;
  174.      loop set1!(r,a.elt1!(r)) end end end;
  175.  
  176.    resize(sz1, sz2:INT):SAME is
  177.       res ::= #SAME(sz1, sz2);
  178.       col:INT;
  179.       
  180.       loop
  181.          size2.min(sz1).times!;
  182.          col := 0.upto!(sz2.min(size1));
  183.          loop
  184.             res.set2!(col, elt2!(col));
  185.          end;
  186.          --(loop)
  187.       end;
  188.       --(loop)
  189.       return (res);
  190.    end;
  191.    --(resize(INT, INT):SAME)
  192.  
  193. end; -- class ARRAY2{T}
  194.  
  195. -------------------------------------------------------------------
  196.    
  197.       
  198.